package com.littlebee.storychild.common.json;

import android.text.TextUtils;

import com.littlebee.storychild.common.utils.LogUtil;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONStringer;

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;


/**
 * @author keane
 * 
 */
public class JsonHelper {
	private static String TAG = "JSONHelper";

	/**
	 * 判断对象是否为空
	 *
	 * @param obj 实例
	 * @return
	 */
	public static boolean isNull(Object obj) {
		if (obj instanceof JSONObject) {
			return JSONObject.NULL.equals(obj);
		}
		return obj == null;
	}

	/**
	 * 将对象转换成Json字符串
	 * @param obj
	 * @return json类型字符串
	 */
	public static String toJSON(Object obj) {
		JSONStringer js = new JSONStringer();
		serialize(js, obj);
		return js.toString();
	}

	/**
	 * 序列化为JSON
	 * @param js json对象
	 * @param o	待需序列化的对象
	 */
	private static void serialize(JSONStringer js, Object o) {
		if (Util.isNull(o)) {
			try {
				js.value(null);
			} catch (JSONException e) {
				e.printStackTrace();
			}
			return;
		}

		Class<?> clazz = o.getClass();
		if (Util.isObject(clazz)) { // 对象
			serializeObject(js, o);
		} else if (Util.isArray(clazz)) { // 数组
			serializeArray(js, o);
		} else if (Util.isCollection(clazz)) { // 集合
			Collection<?> collection = (Collection<?>) o;
			serializeCollect(js, collection);
		}else if (Util.isMap(clazz)) { // 集合
			HashMap<?,?> collection = (HashMap<?,?>) o;
			serializeMap(js, collection);
		} else { // 单个值
			try {
				js.value(o);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 序列化数组 
	 * @param js	json对象
	 * @param array	数组
	 */
	private static void serializeArray(JSONStringer js, Object array) {
		try {
			js.array();
			for (int i = 0; i < Array.getLength(array); ++i) {
				Object o = Array.get(array, i);
				serialize(js, o);
			}
			js.endArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 序列化集合
	 * @param js	json对象
	 * @param collection	集合
	 */
	private static void serializeCollect(JSONStringer js, Collection<?> collection) {
		try {
			js.array();
			for (Object o : collection) {
				serialize(js, o);
			}
			js.endArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 序列化Map
	 * @param js	json对象
	 * @param map	map对象
	 */
	private static void serializeMap(JSONStringer js, Map<?,?> map) {
		try {
			js.object();
			@SuppressWarnings("unchecked")
			Map<String, Object> valueMap = (Map<String, Object>) map;
			Iterator<Map.Entry<String, Object>> it = valueMap.entrySet().iterator();
			while (it.hasNext()) {
				Map.Entry<String, Object> entry = (Map.Entry<String, Object>)it.next();
				js.key(entry.getKey());
				serialize(js,entry.getValue());
			}
			js.endObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 序列化对象
	 * @param js	json对象
	 * @param obj	待序列化对象
	 */
	private static void serializeObject(JSONStringer js, Object obj) {
		try {
			js.object();
			Class<? extends Object> objClazz = obj.getClass();
			Method[] methods = objClazz.getDeclaredMethods();
	        Field[] fields = objClazz.getDeclaredFields();
	        for (Field field : fields) {
	            try {   
	                String fieldType = field.getType().getSimpleName();
	                String fieldGetName = Util.parseMethodName(field.getName(),"get");
	                if (!Util.haveMethod(methods, fieldGetName)) {   
	                    continue;   
	                }   
	                Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});
	                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});
	                String result = null;
	                if ("Date".equals(fieldType)) {   
	                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);
	                    result = sdf.format((Date)fieldVal);

	                } else {   
	                    if (null != fieldVal) {   
	                        result = String.valueOf(fieldVal);
	                    }   
	                }   
	                js.key(field.getName());
					serialize(js, result);  
	            } catch (Exception e) {
	                continue;   
	            }   
	        }  
			js.endObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**  
     * 给字段赋值  
     * @param obj  实例对象
     * @param valMap  值集合
     */  
    public static void setFieldValue(Object obj, Map<String, String> valMap) {
        Class<?> cls = obj.getClass();
        // 取出bean里的所有方法   
        Method[] methods = cls.getDeclaredMethods();
        Field[] fields = cls.getDeclaredFields();
  
        for (Field field : fields) {
            try {     
                String setMetodName = Util.parseMethodName(field.getName(),"set");
                if (!Util.haveMethod(methods, setMetodName)) {   
                    continue;   
                }   
                Method fieldMethod = cls.getMethod(setMetodName, field
                        .getType());   
                String value = valMap.get(field.getName());
                if (null != value && !"".equals(value)) {   
                    String fieldType = field.getType().getSimpleName();
                    if ("String".equals(fieldType)) {   
                        fieldMethod.invoke(obj, value);   
                    } else if ("Date".equals(fieldType)) {   
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);
                        Date temp = sdf.parse(value);
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Integer".equals(fieldType)   
                            || "int".equals(fieldType)) {   
                        Integer intval = Integer.parseInt(value);
                        fieldMethod.invoke(obj, intval);   
                    } else if ("Long".equalsIgnoreCase(fieldType)) {   
                        Long temp = Long.parseLong(value);
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Double".equalsIgnoreCase(fieldType)) {   
                        Double temp = Double.parseDouble(value);
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {   
                        Boolean temp = Boolean.parseBoolean(value);
                        fieldMethod.invoke(obj, temp);   
                    } else {   
                        System.out.println("setFieldValue not supper type:" + fieldType);
                    }   
                }   
            } catch (Exception e) {
                continue;   
            }   
        }   
  
    } 
    
    /**
     * bean对象转Map
     * @param obj	实例对象
     * @return	map集合
     */
    public static Map<String, String> beanToMap(Object obj) {
        Class<?> cls = obj.getClass();
        Map<String, String> valueMap = new HashMap<String, String>();
        // 取出bean里的所有方法   
        Method[] methods = cls.getDeclaredMethods();
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            try {   
                String fieldType = field.getType().getSimpleName();
                String fieldGetName = Util.parseMethodName(field.getName(),"get");
                if (!Util.haveMethod(methods, fieldGetName)) {   
                    continue;   
                }   
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});
                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});
                String result = null;
                if ("Date".equals(fieldType)) {   
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
                    result = sdf.format((Date)fieldVal);

                } else {   
                    if (null != fieldVal) {   
                        result = String.valueOf(fieldVal);
                    }   
                }   
                valueMap.put(field.getName(), result);   
            } catch (Exception e) {
                continue;   
            }   
        }   
        return valueMap;   
  
    }   

	/**
	 * 给对象的字段赋值
	 * @param obj	类实例
	 * @param fieldSetMethod	字段方法
	 * @param fieldType	字段类型
	 * @param value
	 */
	public static void setFiedlValue(Object obj, Method fieldSetMethod, String fieldType, Object value){
        try {    
        	/*
        	 * 解决空串，解析后为null的缺陷；
        	 * write by liaoyong ,2014/5/5
        	 */
			if (null != value) {
            	if ("String".equals(fieldType)) {
                	fieldSetMethod.invoke(obj, value.toString());   
                } else if ("Date".equals(fieldType)) {   
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
                    Date temp = sdf.parse(value.toString());
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Integer".equals(fieldType)   
                        || "int".equals(fieldType)) {
					if (TextUtils.isEmpty(value.toString())) {
						LogUtil.e("error json int type");
						fieldSetMethod.invoke(obj, 0);
					} else {
						Integer intval = Integer.parseInt(value.toString());
						fieldSetMethod.invoke(obj, intval);
					}
                } else if ("Long".equalsIgnoreCase(fieldType)) {   
                    Long temp = Long.parseLong(value.toString());
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Double".equalsIgnoreCase(fieldType)) {
					if (TextUtils.isEmpty(value.toString())) {
						fieldSetMethod.invoke(obj, 0.0);
						LogUtil.e("error json double type");
					} else {
						Double temp = Double.parseDouble(value.toString());
						fieldSetMethod.invoke(obj, temp);
					}
                } else if ("Boolean".equalsIgnoreCase(fieldType)) {   
                    Boolean temp = Boolean.parseBoolean(value.toString());
                    fieldSetMethod.invoke(obj, temp);   
                } else {   
                	fieldSetMethod.invoke(obj, value); 
                } 
			}
        } catch (Exception e) {
        	e.printStackTrace();
        }   
    
	}
	
	/**
	 * 反序列化添加了RestXXX注解的简单对象
	 * @param jo	json对象
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException
	 */
	public static <T> T parseObjectWithRestAnnotation(JSONObject jo, Class<T> clazz) throws JSONException {
		if (clazz == null || Util.isNull(jo)) {
			return null;
		}

		T obj = newInstance(clazz);
		if (obj == null) {
			return null;
		}
		if(Util.isMap(clazz)){ 
			setField(obj,jo);
		}else{
			/*
			String className = clazz.getSimpleName();
			RestClass rc = clazz.getAnnotation(RestClass.class);
			String classBeanAnnoName = rc.name();
			if(!Util.isEmpty(classBeanAnnoName)){
				//按照RestClass的name去解析json
				className = classBeanAnnoName;
			}
			*/
			  // 取出bean里的所有方法   
	        Method[] methods = clazz.getDeclaredMethods();
	        Field[] fields = clazz.getDeclaredFields();
			for (Field f : fields) {
				String setMetodName = Util.parseMethodName(f.getName(),"set");
                if (!Util.haveMethod(methods, setMetodName)) {   
                    continue;   
                }                 
				try {
					Method fieldMethod = clazz.getMethod(setMetodName, f.getType());
					Annotation fanno = f.getAnnotation(RestProperty.class);
					String fieldAnno = "";
					if(fanno != null){
						fieldAnno = ((RestProperty)fanno).name();
					}
					if(!Util.isEmpty(fieldAnno)){
						setFieldWithAnno(obj,fieldMethod,f, jo);
					}else{
						setField(obj,fieldMethod,f, jo);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}  
			}
		}
		return obj;
	}
	
	/**
	 * 反序列化简单对象
	 * @param jo	json对象
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException
	 */
	public static <T> T parseObject(JSONObject jo, Class<T> clazz) throws JSONException {
		if (clazz == null || Util.isNull(jo)) {
			return null;
		}

		T obj = newInstance(clazz);
		if (obj == null) {
			return null;
		}
		if(Util.isMap(clazz)){ 
			setField(obj,jo);
		}else{
			  // 取出bean里的所有方法   
	        Method[] methods = clazz.getDeclaredMethods();
	        Field[] fields = clazz.getDeclaredFields();
			for (Field f : fields) {
				String setMetodName = Util.parseMethodName(f.getName(),"set");
                if (!Util.haveMethod(methods, setMetodName)) {   
                    continue;   
                }                 
				try {
					Method fieldMethod = clazz.getMethod(setMetodName, f.getType());
					Annotation fanno = f.getAnnotation(RestProperty.class);
					String fieldAnno = "";
					if(fanno != null){
						fieldAnno = ((RestProperty)fanno).name();
					}
					if(!Util.isEmpty(fieldAnno)){
						setFieldWithAnno(obj,fieldMethod,f, jo);
					}else{
						setField(obj,fieldMethod,f, jo);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}  
			}
		}
		return obj;
	}
	
	/**
	 * 根据RestClass的name来反序列化简单对象
	 * @param jo	json对象
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException
	 */
	public static <T> T parseObjectWithAnno(JSONObject jo, Class<T> clazz) throws JSONException {
		if (clazz == null || Util.isNull(jo)) {
			return null;
		}

		T obj = newInstance(clazz);
		if (obj == null) {
			return null;
		}
		if(Util.isMap(clazz)){ 
			setField(obj,jo);
		}else{
//			  // 取出bean里的所有方法   
//	        Method[] methods = clazz.getDeclaredMethods();   
//	        Field[] fields = clazz.getDeclaredFields();   	        
//			for (Field f : fields) {
//				String setMetodName = parseMethodName(f.getName(),"set");   
//                if (!haveMethod(methods, setMetodName)) {   
//                    continue;   
//                }                 
//				try {
//					Method fieldMethod = clazz.getMethod(setMetodName, f.getType());
//					setFieldWithAnno(obj,fieldMethod,f, jo);
//				} catch (Exception e) {
//					e.printStackTrace();
//				}  
//			}
			Annotation canno = clazz.getAnnotation(RestClass.class);
			if( canno != null){
				String classBeanAnnoName = ((RestClass)canno).name();
				if( !Util.isEmpty(classBeanAnnoName) ){
					JSONObject jsonObject = jo;
					return parseObjectWithRestAnnotation(jsonObject,clazz);

//					return parseObjectWithRestAnnotation(jo.getJSONObject(classBeanAnnoName),clazz);
				}else{
					return parseObject(jo.getJSONObject(clazz.getSimpleName()),clazz);
				}
			}else{
				return parseObject(jo.getJSONObject(clazz.getSimpleName()),clazz);
			}
		}
		return obj;
	}
	
	/**
	 * 反序列化简单对象
	 * @param jsonStr	json字符串
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException
	 */
	public static <T> T parseObject(String jsonStr, Class<T> clazz) throws JSONException {
		if (clazz == null || jsonStr == null || jsonStr.length() == 0) {
			return null;
		}
		
		JSONObject jo = null;
		jo = new JSONObject(jsonStr);
		if (Util.isNull(jo)) {
			return null;
		}

		return parseObject(jo, clazz);
	}

	/**
	 * 反序列化数组对象
	 * @param ja	json数组
	 * @param clazz	实体类类型
	 * @return	反序列化后的数组
	 */
	public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {
		if (clazz == null || Util.isNull(ja)) {
			return null;
		}

		int len = ja.length();

		@SuppressWarnings("unchecked")
		T[] array = (T[]) Array.newInstance(clazz, len);

		for (int i = 0; i < len; ++i) {
			try {
				JSONObject jo = ja.getJSONObject(i);
				T o = parseObject(jo, clazz);
				array[i] = o;
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}

		return array;
	}

	
	/**
	 * 反序列化数组对象
	 * @param jsonStr	json字符串
	 * @param clazz	实体类类型
	 * @return	序列化后的数组
	 */
	public static <T> T[] parseArray(String jsonStr, Class<T> clazz) {
		if (clazz == null || jsonStr == null || jsonStr.length() == 0) {
			return null;
		}
		JSONArray jo = null;
		try {
			jo = new JSONArray(jsonStr);
		} catch (JSONException e) {
			e.printStackTrace();
		}

		if (Util.isNull(jo)) {
			return null;
		}

		return parseArray(jo, clazz);
	}
	
	/**
	 * 反序列化泛型集合
	 * @param ja	json数组
	 * @param collectionClazz	集合类型
	 * @param genericType	实体类类型
	 * @return
	 * @throws JSONException
	 */
	@SuppressWarnings("unchecked")
	public static <T> Collection<T> parseCollectionWithAnnotation(JSONArray ja, Class<?> collectionClazz,
																  Class<T> genericType) throws JSONException {

		if (collectionClazz == null || genericType == null || Util.isNull(ja)) {
			return null;
		}

		Collection<T> collection = (Collection<T>) newInstance(collectionClazz);

		for (int i = 0; i < ja.length(); ++i) {
			try {
				JSONObject jo = ja.getJSONObject(i);
				T o = parseObjectWithAnno(jo, genericType);
				collection.add(o);
			} catch (JSONException e) {
				e.printStackTrace();
				LogUtil.e("json parse error" + e.getMessage());
			}
		}

		return collection;
	}

	/**
	 * 反序列化泛型集合
	 * @param ja	json数组
	 * @param collectionClazz	集合类型
	 * @param genericType	实体类类型
	 * @return
	 * @throws JSONException
	 */
	@SuppressWarnings("unchecked")
	public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,
													Class<T> genericType) throws JSONException {

		if (collectionClazz == null || genericType == null || Util.isNull(ja)) {
			return null;
		}

		Collection<T> collection = (Collection<T>) newInstance(collectionClazz);

		for (int i = 0; i < ja.length(); ++i) {
			try {
				Object object = ja.get(i);
				if (object instanceof JSONObject) {
					T o = parseObject((JSONObject) object, genericType);
					collection.add(o);
				} else {
					collection.add((T) object);
				}

//				JSONObject jo = ja.getJSONObject(i);
//				T o = parseObject(jo, genericType);
//				collection.add(o);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}

		return collection;
	}

	/**
	 * 反序列化泛型集合
	 * @param jsonStr	json字符串
	 * @param collectionClazz	集合类型
	 * @param genericType	实体类类型
	 * @return	反序列化后的数组
	 * @throws JSONException
	 */
	public static <T> Collection<T> parseCollection(String jsonStr, Class<?> collectionClazz,
													Class<T> genericType) throws JSONException {
		if (collectionClazz == null || genericType == null || jsonStr == null
				|| jsonStr.length() == 0) {
			return null;
		}
		JSONArray jo = null;
		try {
			//如果为数组，则此处转化时，需要去掉前面的键，直接后面的[]中的值
			int index = jsonStr.indexOf("[");
			String arrayString=null;
			
			//获取数组的字符串
			if(-1!=index){
				arrayString = jsonStr.substring(index);
			}
			
			//如果为数组，使用数组转化
			if(null!=arrayString){
				jo = new JSONArray(arrayString);
			}
			else{
				jo = new JSONArray(jsonStr);
			}
			
		} catch (JSONException e) {
			e.printStackTrace();
		}

		if (Util.isNull(jo)) {
			return null;
		}

		return parseCollection(jo, collectionClazz, genericType);
	}

	/**
	 * 根据类型创建对象
	 * @param clazz	待创建实例的类型
	 * @return	实例对象
	 * @throws JSONException
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private static <T> T newInstance(Class<T> clazz) throws JSONException {
		if (clazz == null)
			return null;
		T obj = null;
		if (clazz.isInterface()) {
			if (clazz.equals(Map.class)) {
				obj = (T) new HashMap();
			}else if (clazz.equals(List.class)) {
				obj = (T) new ArrayList();
			}else if (clazz.equals(Set.class)) {
				obj = (T) new HashSet();
			}else{
				throw new JSONException("unknown interface: " + clazz);
			}
		}else{
			try {
				obj = clazz.newInstance();
			}catch (Exception e) {
				throw new JSONException("unknown class type: " + clazz);
			}
		}	
		return obj;
	}
	
	/**
	 * 设定Map的值
	 * @param obj	待赋值字段的对象
	 * @param jo	json实例
	 */
	private static void setField(Object obj, JSONObject jo) {
		try {
			@SuppressWarnings("unchecked")
			Iterator<String> keyIter = jo.keys();
			String key;
			Object value;
			@SuppressWarnings("unchecked")
			Map<String, Object> valueMap = (Map<String, Object>) obj;
			while (keyIter.hasNext()) {
				key = (String) keyIter.next();
				value = jo.get(key);				
				valueMap.put(key, value);

			}
		} catch (JSONException e) {
			e.printStackTrace();
		}
	}	
	
	/**
	 * 设定字段的值
	 * @param obj	待赋值字段的对象
	 * @param fieldSetMethod	字段方法名
	 * @param field	字段
	 * @param jo	json实例
	 */
	private static void setField(Object obj, Method fieldSetMethod, Field field, JSONObject jo) {
		String name = field.getName();
		Class<?> clazz = field.getType();
		try {
			if (Util.isArray(clazz)) { // 数组
				Class<?> c = clazz.getComponentType();
				JSONArray ja = jo.optJSONArray(name);
				if (!Util.isNull(ja)) {
					Object array = parseArray(ja, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);
				}
			} else if (Util.isCollection(clazz)) { // 泛型集合
				// 获取定义的泛型类型
				Class<?> c = null;
				Type gType = field.getGenericType();
				if (gType instanceof ParameterizedType) {
					ParameterizedType ptype = (ParameterizedType) gType;
					Type[] targs = ptype.getActualTypeArguments();
					if (targs != null && targs.length > 0) {
						Type t = targs[0];
						c = (Class<?>) t;
					}
				}

				JSONArray ja = jo.optJSONArray(name);
				if (!Util.isNull(ja)) {
					Object o = parseCollection(ja, clazz, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (Util.isSingle(clazz)) { // 值类型
				Object o = jo.opt(name);
				if (o != null) {
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (Util.isObject(clazz)) { // 对象
				JSONObject j = jo.optJSONObject(name);
				if (!Util.isNull(j)) {
					Object o = parseObject(j, clazz);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (Util.isList(clazz)) { // 列表
//				JSONObject j = jo.optJSONObject(name);
//				if (!isNull(j)) {
//					Object o = parseObject(j, clazz);
//					f.set(obj, o);
//				}
			} else {
				throw new Exception("unknow type!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 设定字段的值 
	 * @param obj	待赋值字段的对象
	 * @param field	字段
	 * @param jo	json实例
	 */
	@SuppressWarnings("unused")
	private static void setField(Object obj, Field field, JSONObject jo) {
		String name = field.getName();
		Class<?> clazz = field.getType();
		try {
			if (Util.isArray(clazz)) { // 数组
				Class<?> c = clazz.getComponentType();
				JSONArray ja = jo.optJSONArray(name);
				if (!Util.isNull(ja)) {
					Object array = parseArray(ja, c);
					field.set(obj, array);
				}
			} else if (Util.isCollection(clazz)) { // 泛型集合
				// 获取定义的泛型类型
				Class<?> c = null;
				Type gType = field.getGenericType();
				if (gType instanceof ParameterizedType) {
					ParameterizedType ptype = (ParameterizedType) gType;
					Type[] targs = ptype.getActualTypeArguments();
					if (targs != null && targs.length > 0) {
						Type t = targs[0];
						c = (Class<?>) t;
					}
				}
				JSONArray ja = jo.optJSONArray(name);
				if (!Util.isNull(ja)) {
					Object o = parseCollection(ja, clazz, c);
					field.set(obj, o);
				}
			} else if (Util.isSingle(clazz)) { // 值类型
				Object o = jo.opt(name);
				if (o != null) {
					field.set(obj, o);
				}
			} else if (Util.isObject(clazz)) { // 对象
				JSONObject j = jo.optJSONObject(name);
				if (!Util.isNull(j)) {
					Object o = parseObject(j, clazz);
					field.set(obj, o);
				}
			} else if (Util.isList(clazz)) { // 列表
				JSONObject j = jo.optJSONObject(name);
				if (!Util.isNull(j)) {
					Object o = parseObject(j, clazz);
					field.set(obj, o);
				}
			}else {
				throw new Exception("unknow type!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 根据类里面的RestXXX注解作为Key去解析json，然后设定字段的值
	 * @param obj	待赋值字段的对象
	 * @param fieldSetMethod	字段方法名
	 * @param field	字段
	 * @param jo	json实例
	 */
	private static void setFieldWithAnno(Object obj, Method fieldSetMethod, Field field, JSONObject jo) {
		
		//解析每个json 键值对要用到的key
		String name = "";
		Annotation fanno = field.getAnnotation(RestProperty.class);
		if( fanno != null){
			name = ((RestProperty)fanno).name();
			if(Util.isEmpty(name)){
				name = field.getName();
			}
		}else{
			name = field.getName();
		}
		Class<?> clazz = field.getType();
		try {
			if (Util.isArray(clazz)) { // 数组
				Class<?> c = clazz.getComponentType();
				JSONArray ja = jo.optJSONArray(name);
				if (!Util.isNull(ja)) {
					Object array = parseArray(ja, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);
				}
			} else if (Util.isCollection(clazz)) { // 泛型集合
				// 获取定义的泛型类型
				Class<?> c = null;
				Type gType = field.getGenericType();
				if (gType instanceof ParameterizedType) {
					ParameterizedType ptype = (ParameterizedType) gType;
					Type[] targs = ptype.getActualTypeArguments();
					if (targs != null && targs.length > 0) {
						Type t = targs[0];
						c = (Class<?>) t;
					}
				}

				JSONArray ja = jo.optJSONArray(name);
				if (!Util.isNull(ja)) {
					Object o = parseCollection(ja, clazz, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (Util.isSingle(clazz)) { // 值类型
				Object o = jo.opt(name);
				if (o != null) {
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (Util.isObject(clazz)) { // 对象
				JSONObject j = jo.optJSONObject(name);
				if (!Util.isNull(j)) {
					Object o = parseObject(j, clazz);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (Util.isList(clazz)) { // 列表
//				JSONObject j = jo.optJSONObject(name);
//				if (!isNull(j)) {
//					Object o = parseObject(j, clazz);
//					f.set(obj, o);
//				}
			} else {
				throw new Exception("unknow type!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}	
}
